const dayjs = require('dayjs');
/**
 * 研发项目流程管理模块
 * 负责处理研发项目的状态流转、流程控制、事件触发等功能
 */

// 引入辅助工具
const cloudHelper = require('./helpers/cloud_helper.js');
const pageHelper = require('./helpers/page_helper.js');
const timeHelper = require('./helpers/time_helper.js');

/**
 * 流程管理器类
 * 用于处理研发项目中的流程流转
 */
class FlowManager {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   * @param {Object} stateMachineStore - 状态机Store
   */
  constructor(page, stateMachineStore) {
    this.page = page;
    this.stateMachineStore = stateMachineStore;
    this.cacheTime = 5 * 60 * 1000; // 缓存5分钟
    this.cacheData = {};
  }

  /**
   * 初始化流程管理器
   * @param {Object} project - 项目信息
   * @param {string} currentRole - 当前用户角色
   */
  init(project, currentRole) {
    if (!project) return;
    
    // 设置项目信息
    if (this.stateMachineStore && this.stateMachineStore.setProject) {
      this.stateMachineStore.setProject(project);
    }
    
    // 设置当前角色
    if (this.stateMachineStore && this.stateMachineStore.setCurrentRole) {
      this.stateMachineStore.setCurrentRole(currentRole);
    }
    
    // 加载可用事件
    this.loadAvailableEvents();
  }

  /**
   * 获取项目流程历史
   * @param {string} projectId - 项目ID
   * @param {boolean} useCache - 是否使用缓存
   * @returns {Promise<Array>} 流程历史记录
   */
  async getFlowHistory(projectId, useCache = true) {
    // 检查参数
    if (!projectId) {
      console.warn('获取流程历史：项目ID为空');
      return [];
    }
    
    // 检查缓存
    const cacheKey = `flow_history_${projectId}`;
    if (useCache && this.cacheData[cacheKey] && (dayjs().valueOf() - this.cacheData[cacheKey].time < 10 * 60 * 1000)) {
      return this.cacheData[cacheKey].data;
    }
    
    // 准备查询参数
    const params = {
      projectId: projectId
    };
    
    try {
      let result = [];
      
      // 如果状态机Store中有加载流程历史方法，优先使用
      if (this.stateMachineStore && this.stateMachineStore.loadFlowHistory) {
        result = await this.stateMachineStore.loadFlowHistory(projectId);
      } else {
        // 否则直接请求服务器
        result = await cloudHelper.callCloudData('research/get_flow_history', params);
      }
      
      // 处理时间显示
      if (result && Array.isArray(result)) {
        result.forEach(item => {
          if (item && item.FLOW_TIME) {
            item.FLOW_TIME_DISPLAY = timeHelper.formatDateTime(item.FLOW_TIME);
          }
        });
        
        // 更新缓存
        this.cacheData[cacheKey] = {
          time: dayjs().valueOf(),
          data: result
        };
      } else {
        // 如果结果不是数组，返回空数组
        console.warn('获取流程历史：返回结果不是数组', result);
        result = [];
      }
      
      return result;
    } catch (error) {
      console.error('获取流程历史失败', error);
      // 避免在UI上显示错误信息
      // pageHelper.showError('获取流程历史记录失败');
      return [];
    }
  }

  /**
   * 加载可用事件列表
   * @returns {Array} 可用事件列表
   */
  loadAvailableEvents() {
    if (!this.stateMachineStore || !this.stateMachineStore.getAvailableEvents) {
      console.error('状态机Store未提供getAvailableEvents方法');
      return [];
    }
    
    try {
      const availableEvents = this.stateMachineStore.getAvailableEvents();
      return availableEvents;
    } catch (error) {
      console.error('加载可用事件列表失败', error);
      return [];
    }
  }

  /**
   * 加载状态所需资源
   * @param {number} eventIndex - 事件索引
   * @returns {Array} 所需资源列表
   */
  loadEventRequiredResources(eventIndex) {
    if (!this.stateMachineStore || !this.stateMachineStore.loadRequiredResources) {
      console.error('状态机Store未提供loadRequiredResources方法');
      return [];
    }
    
    try {
      const requiredResources = this.stateMachineStore.loadRequiredResources(eventIndex);
      return requiredResources;
    } catch (error) {
      console.error('加载状态所需资源失败', error);
      return [];
    }
  }

  /**
   * 校验状态转换
   * @param {string} eventId - 事件ID
   * @returns {boolean} 是否可以进行状态转换
   */
  validateStateTransition(eventId) {
    if (!this.stateMachineStore || !this.stateMachineStore.canPerformStateTransition) {
      console.error('状态机Store未提供canPerformStateTransition方法');
      return false;
    }
    
    try {
      return this.stateMachineStore.canPerformStateTransition(eventId);
    } catch (error) {
      console.error('校验状态转换失败', error);
      return false;
    }
  }

  /**
   * 提交状态转换
   * @param {Object} params - 状态转换参数
   * @returns {Promise<Object>} 状态转换结果
   */
  async submitStateTransition(params) {
    if (!this.stateMachineStore || !this.stateMachineStore.performStateTransition) {
      console.error('状态机Store未提供performStateTransition方法');
      throw new Error('状态机功能不可用');
    }
    
    try {
      const result = await this.stateMachineStore.performStateTransition(params);
      
      // 清除缓存
      const cacheKey = `flow_history_${params.projectId}`;
      if (this.cacheData[cacheKey]) {
        delete this.cacheData[cacheKey];
      }
      
      return result;
    } catch (error) {
      console.error('提交状态转换失败', error);
      throw error;
    }
  }

  /**
   * 获取项目进度
   * @param {Object} project - 项目信息
   * @returns {number} 项目进度(0-100)
   */
  getProjectProgress(project) {
    if (!project) return 0;

    try {
      // 如果状态机Store提供了进度计算方法，则使用
      if (this.stateMachineStore && this.stateMachineStore.calculateProgress) {
        return this.stateMachineStore.calculateProgress(project);
      }
      
      // 否则使用简单的进度计算
      const statusMap = {
        '项目审核': 10,
        '硬件确认': 20,
        '硬件': 30,
        '调试': 50,
        '测试': 60,
        '客户确认': 70,
        '订单准备': 80,
        '生产': 90,
        '待反馈': 95
      };
      
      // 获取主状态和子状态
      const mainStatus = project.RESEARCH_STATUS || '';
      
      // 返回主状态对应的进度，如果没有则返回0
      return statusMap[mainStatus] || 0;
    } catch (error) {
      console.error('计算项目进度失败', error);
      return 0;
    }
  }

  /**
   * 获取未完成项目
   * @param {Object} project - 项目信息
   * @returns {Array} 未完成项目列表
   */
  getUnfinishedItems(project) {
    if (!project) return [];

    try {
      // 如果状态机Store提供了获取未完成项目的方法，则使用
      if (this.stateMachineStore && this.stateMachineStore.getUnfinishedItems) {
        return this.stateMachineStore.getUnfinishedItems(project);
      }
      
      // 否则返回空数组
      return [];
    } catch (error) {
      console.error('获取未完成项目失败', error);
      return [];
    }
  }

  /**
   * 格式化状态显示文本
   * @param {Object} project - 项目信息
   * @returns {Object} 包含状态显示文本的对象
   */
  formatStatusText(project) {
    if (!project) return { statusText: '未知', statusClass: '' };

    try {
      const mainStatus = project.RESEARCH_STATUS || '';
      const subStatus = project.RESEARCH_SUB_STATUS || '';
      
      // 状态显示类名映射
      const statusClassMap = {
        '项目审核': 'status-review',
        '硬件确认': 'status-hardware-confirm',
        '硬件': 'status-hardware',
        '调试': 'status-debug',
        '测试': 'status-test',
        '客户确认': 'status-customer',
        '订单准备': 'status-order',
        '生产': 'status-production',
        '待反馈': 'status-feedback',
        '休眠': 'status-sleep'
      };
      
      // 格式化状态显示文本
      let statusText = mainStatus;
      if (subStatus) {
        statusText += ` - ${subStatus}`;
      }
      
      return {
        statusText: statusText,
        statusClass: statusClassMap[mainStatus] || ''
      };
    } catch (error) {
      console.error('格式化状态显示文本失败', error);
      return { statusText: '未知', statusClass: '' };
    }
  }

  /**
   * 检查用户是否有流转权限
   * @param {Object} project - 项目信息
   * @param {string} userRole - 用户角色
   * @returns {boolean} 是否有流转权限
   */
  checkFlowPermission(project, userRole) {
    if (!project || !userRole) return false;

    try {
      // 如果状态机Store提供了检查权限的方法，则使用
      if (this.stateMachineStore && this.stateMachineStore.checkPermission) {
        return this.stateMachineStore.checkPermission(project, userRole);
      }
      
      // 主状态和用户角色的权限映射
      const permissionMap = {
        '项目审核': ['董事长', '研发经理'],
        '硬件确认': ['硬件工程师'],
        '硬件': ['硬件工程师', '研发经理'],
        '调试': ['软件工程师'],
        '测试': ['测试组人员'],
        '客户确认': ['业务人员', '董事长'],
        '订单准备': ['业务人员', '董事长', '文控'],
        '生产': ['生产主管', 'PE'],
        '待反馈': ['业务人员', '董事长'],
        '休眠': ['研发经理']
      };
      
      // 获取主状态
      const mainStatus = project.RESEARCH_STATUS || '';
      
      // 获取当前主状态允许的角色列表
      const allowedRoles = permissionMap[mainStatus] || [];
      
      // 检查用户角色是否在允许的角色列表中
      return allowedRoles.includes(userRole);
    } catch (error) {
      console.error('检查流转权限失败', error);
      return false;
    }
  }
}

module.exports = FlowManager; 